As the web browsing experience begins to evolve from a flat presentation of information with minimal interactivity to a richer application or applet experience with lots of interactivity at the client side, or more generally, a hybrid of information display and richer interactivity with objects on display, there are a variety of challenges based on evolving the old document object model (DOM) originally designed primarily for flat presentation of information based on native code on a client to an experience that fluidly handles script code, such as javascript objects. For instance, speeding the user experience up is a main challenge.
For instance, with fly out menus of the past, the web experience flickered with delays based on communications with the server. Script enables small programs to modify the DOM on the fly without going back to the server, e.g., Asynchronous JavaScript and extensible markup language (AJAX). As people want to do more and more on the fly without returning to the server, making script code execute fast has become a challenge.
Since the user experience centers on scripting the DOM, it is desirable to be able to change the DOM very fast since that maximizes the interactive response. Communication between the scripting engines and the native classes of the DOM were poor in the past due to the use of OLE automation including a set of interfaces, iDispatch, iActiveScript, etc., which make any object scriptable. In addition, a variety of Component Object Model (COM) objects may be indiscriminately created today, but which may be unnecessary, or otherwise introduce overhead maintaining the objects, slowing down performance.
In short, to date, there have been no web browsing systems designed specifically around efficient code generation for marshaling between script and native worlds for COM data structures, or around memory management designed for COM and COM data structures. In this regard, COM is a binary-interface standard for software components used to enable interprocess communication and dynamic object creation in a large range of programming languages.
Basically, COM is a language-neutral way of implementing objects that can be used in environments different from the one in which they were created, even across machine boundaries. For well-authored components, COM allows reuse of objects with no knowledge of their internal implementation, as it forces component implementers to provide well-defined interfaces that are separate from the implementation. The different allocation semantics of languages are accommodated by making objects responsible for their own creation and destruction through reference-counting. Casting between different interfaces of an object is achieved through the QueryInterface( ) function. The preferred method of inheritance within COM is the creation of sub-objects to which method calls are delegated.
However, as mentioned, conventional web browsing has evolved in a way that can lead to inefficient use of COM constructs, noticeably affecting performance of a web browsing experience, and modern fast broadband data connections make such delays more noticeable, allowing for greater margins of improvement in the user experience.
The above-described deficiencies of today's code generation and memory management schemes are merely intended to provide an overview of some of the problems of conventional systems, and are not intended to be exhaustive. Other problems with the state of the art and corresponding benefits of some of the various non-limiting embodiments may become further apparent upon review of the following detailed description.